Modul 11 von 16 · 📖 9 min Lesezeit · ⏱ 30 min gesamt

FI-AE 11 Testing — Unit, Integration, E2E

Inhaltsverzeichnis (6 Abschnitte)

Konzepte und Hintergrund
Architektur-Diagramm
Praktische Schritte
Häufige Fallstricke
Weiterführende Ressourcen
Wissens-Check

FI-AE 11 Testing — Unit, Integration, E2E

Softwarequalität beginnt mit gezieltem Testing. Dieses Modul führt Sie in die Methoden des modernen Softwaretestings ein. Sie lernen die Testpyramide zu verstehen, Unit-Tests, Integrationstests und End-to-End-Tests effektiv zu gestalten sowie Mocking-Techniken für isolierte Testumgebungen anzuwenden. Der Fokus liegt auf praktischer Umsetzung mit TDD-Ansatz und sinnvoller Code-Coverage-Messung in CI-Pipelines.

Konzepte und Hintergrund

Testpyramide: Ein Modell zur Verteilung von Testarten, das eine große Basis von Unit-Tests, eine mittlere Schicht von Integrationstests und eine Spitze von End-to-End-Tests vorsieht. Die Breite der Basis steht für die hohe Anzahl schneller, isolierter Tests während die Spitze wenige, aber umfassende Systemtests repräsentiert.
Mocking: Technik zum Ersetzen von Abhängigkeiten durch kontrollierte Doubles, die vordefinierte Antworten liefern. Erlaubt isolierte Tests von Komponenten, die auf externe Ressourcen wie Datenbanken oder APIs angewiesen sind, ohne diese tatsächlich aufrufen zu müssen.
TDD (Test-Driven Development): Entwicklungsansatz, bei dem zuerst ein Test für eine noch nicht existierende Funktion geschrieben wird. Erst wenn dieser Test fehlschlägt, wird der minimale Code implementiert, der den Test erfolgreich bestehen lässt. Der Zyklus wiederholt sich mit Refactoring.
Code-Coverage: Metrik zur Messung, welcher Anteil des Quellcodes durch Tests ausgeführt wird. Wichtige Kennzahlen sind Zeilen-, Zweige- und Pfad-Coverage. Hohe Coverage garantiert nicht automatisch Qualität, aber sie deckt ungetestete Codebereiche auf.
CI-Integration: Einbindung von Tests in Continuous-Integration-Pipelines, um automatisierte Qualitätsprüfungen bei jedem Code-Commit durchzuführen. Stellt sicher, dass Tests regelmäßig ausgeführt werden und Regressionen frühzeitig erkannt werden.

Architektur-Diagramm

flowchart TD
    A[Code] --> B[Unit Tests]
    A --> C[Integration Tests]
    A --> D[E2E Tests]
    B --> E[Test Runner]
    C --> E
    D --> E
    E --> F[CI Pipeline]
    F --> G[Test Report]
    F --> H[Code Coverage]
    F --> I[Build Status]

Praktische Schritte

Einheitstest-Framework für Ihre Sprache installieren und konfigurieren. Dies bildet die Grundlage für alle weiteren Testaktivitäten.
Erstellen Sie einen einfachen Unit-Test für eine grundlegende Funktion mit einem positiven und einem negativen Testfall. Dies stellt sicher, dass Ihr Test-Setup korrekt funktioniert.
Implementieren Sie Mocks für externe Abhängigkeiten mit einem Mocking-Framework wie Mockito oder sinon.js. Erlaubt Ihnen, Tests isoliert und schnell auszuführen.
Schreiben Sie Integrationstests, die die Interaktion zwischen mehreren Komponenten überprüfen. Diese Tests decken auf Unit-Ebene nicht sichtbare Fehler auf.
Integrieren Sie Tests in Ihren Build-Prozess mit einem Befehl wie
```
npm test
```
oder
```
mvn test
```
. Automatisierte Tests sind essenziell für CI/CD.
Konfigurieren Sie Code-Coverage-Berichte mit Tools wie JaCoCo oder Istanbul. Dies gibt Ihnen Einblicke, welche Code-Teile durch Tests abgedeckt sind.
Implementieren Sie einen TDD-Zyklus: Rot (Test schreiben, scheitern), Grün (minimalen Code schreiben), Refactoring. Dies verbessert die Codequalität und Design.
Erstellen Sie End-to-End-Tests mit Tools wie Cypress oder Selenium, die Benutzerinteraktionen simulieren. Diese Tests verifizieren das gesamte System aus Benutzerperspektive.
Integrieren Sie Tests in Ihre CI-Pipeline mit einem Befehl wie
```
git commit -m "Add feature" && git push origin main
```
. Dies stellt sicher, dass Tests automatisch bei jedem Commit ausgeführt werden.
Analysieren Sie Testberichte und Coverage-Metriken regelmäßig, um Schwachstellen im Testdesign zu identifizieren und zu beheben.

Häufige Fallstricke

Weiterführende Ressourcen

Wissens-Check

Vier Fragen zur Selbstkontrolle. Klicken Sie jede Frage an, um die richtige Antwort und Erklärung zu sehen.

Welches Prinzip beschreibt die Testpyramide korrekt?

A) Je höher in der Pyramide, desto mehr Tests sollten durchgeführt werden.
B) Die Basis der Pyramide besteht aus vielen schnellen Unit-Tests, während die Spitze wenige langsame E2E-Tests enthält.
C) Alle Tests sollten gleichmäßig über alle Ebenen der Pyramide verteilt sein.
D) Die Testpyramide besagt, dass Integrationstests wichtiger sind als Unit-Tests.

Richtige Antwort: B. Die Testpyramide modelliert, dass viele schnelle, isolierte Unit-Tests die Basis bilden, während wenige umfassende E2E-Tests die Spitze bilden. Option A ist falsch, da mehr Tests in der Basis benötigt werden. Option C ignoriert die unterschiedliche Geschwindigkeit und Reichweite der Testarten. Option D ist falsch, da beide Testarten wichtig sind, aber unterschiedliche Zwecke erfüllen.

Was ist der Hauptvorteil von Mocking im Softwaretesting?

A) Es beschleunigt die Ausführung von Tests, indem echte Abhängigkeiten ersetzt werden.
B) Es ermöglicht das Testen von Komponenten, die von externen Ressourcen abhängen, ohne diese tatsächlich aufrufen zu müssen.
C) Es erhöht die Code-Coverage automatisch.
D) Es eliminiert die Notwendigkeit von Integrationstests vollständig.

Richtige Antwort: B. Mocking ermöglicht isolierte Tests von Komponenten, die auf externe Ressourcen angewiesen sind, ohne diese tatsächlich aufrufen zu müssen. Option A ist teilweise richtig, aber nicht der Hauptvorteil. Option C ist falsch, da Mocking selbst die Coverage nicht erhöht. Option D ist falsch, da Mocking Integrationstests nicht überflüssig macht.

Was ist der grundlegende Zyklus von TDD (Test-Driven Development)?

A) Schreiben des Codes, dann Schreiben des Tests, dann Refactoring.
B) Schreiben des Tests, dann Implementierung des minimalen Codes, um den Test zu bestehen, dann Refactoring.
C) Schreiben der Anforderungen, dann Schreiben des Codes, dann Schreiben des Tests.
D) Schreiben des Tests, dann Implementierung aller Funktionen, dann Ausführung des Tests.

Richtige Antwort: B. TDD beginnt mit dem Schreiben eines Tests für eine noch nicht existierende Funktion, gefolgt von der Implementierung des minimalen Codes, der den Test bestehen lässt, und endet mit Refactoring. Option A ist falsch, da der Test vor dem Code geschrieben wird. Option C ignoriert den testgetriebenen Ansatz. Option D ist falsch, da nicht alle Funktionen implementiert werden, sondern nur die minimal notwendige.

Warum ist die Integration von Tests in CI-Pipelines wichtig?

A) Um die Ausführungszeit von Tests zu minimieren.
B) Um sicherzustellen, dass Tests bei jedem Code-Commit automatisch ausgeführt werden und Regressionen früh erkannt werden.
C) Um die Anzahl der benötigten Tests zu reduzieren.
D) Um die manuelle Testdauer zu verkürzen.

Richtige Antwort: B. Die CI-Integration stellt sicher, dass Tests automatisch bei jedem Code-Commit ausgeführt werden, sodass Regressionen früh erkannt werden. Option A ist falsch, da CI-Pipelines nicht primär auf Geschwindigkeit abzielen. Option C ist falsch, da die Anzahl der Tests nicht reduziert wird. Option D ist falsch, da CI-Pipelines automatisiert sind und nicht manuelle Tests ersetzen.